package Day014_Lambda表达式_Stream流.demo03_Stream流常用方法;

import java.util.stream.Stream;

/**
 * @author zhangyan
 * @date 2020/5/5 11:52
 */
/*
    终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不支持链式调用

    非终结方法(延迟方法)：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用


    终结方法:(返回值不是Stream类型)

        1. long count()     统计个数

        2. forEach()        逐一处理
           void forEach(Consumer<? super T> action)
           该方法接收一个 Consumer<T> 函数式接口类型，抽象方法: void accept(T t);
           所以参数可以传入Lambda表达式

    延迟方法:(返回值是Stream类型的方法)

        3. filter      过滤,得到一个新的流
           Stream<T> filter(Predicate<? super T> predicate);
           该接口接收一个 Predicate 函数式接口参数（可以是一个Lambda或方法引用）作为筛选条件
           所以参数可以传入Lambda表达式

        4. limit       取用前几个
           Stream<T> limit(long maxSize);
           skip        跳过前几个
           Stream<T> skip(long n);

        5. map         映射,将流中的元素映射到另一个流中，可以使用 map 方法
           <R> Stream<R> map(Function<? super T, ? extends R> mapper);
           该接口需要一个 Function 函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。
           所以参数可以传入Lambda表达式

        6. concat      组合,有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat
           static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
           这是一个静态方法，与 java.lang.String 当中的 concat 方法是不同的
*/
public class Test {
    public static void main(String[] args) {
    //   //1.count
    //   Stream<String> stream1 = Stream.of("谢霆锋", "张柏芝", "王宝强", "马蓉");
    //   long count = stream1.count();
    //   //链式调用
    //   long count1 = Stream.of("谢霆锋", "张柏芝", "王宝强", "马蓉").count();
    //   System.out.println(count1);

    //   //2.forEach
    //   Stream<String> stream2 = Stream.of("谢霆锋", "张柏芝", "王宝强", "马蓉");
    //   //对stream2流中的每个元素进行打印
    //   //stream2.forEach((String e)->{ System.out.println(e); });
    //   //Lambda省略格式
    //   stream2.forEach(e -> System.out.println(e));
    //   //3.filter
    //   Stream<String> stream3 = Stream.of("谢霆锋", "张柏芝", "王宝强", "马蓉");
    //   stream3.filter((String e) -> {
    //       return e.startsWith("张");
    //   }).forEach(e -> System.out.println(e));

    //   //4.limit  skip
    //   Stream<String> stream4 = Stream.of("谢霆锋", "张柏芝", "王宝强", "马蓉");
    //   Stream<String> limit = stream4.limit(2);
    //   limit.forEach(e-> System.out.println(e));

    //   stream4.skip(2).forEach(e -> System.out.println(e));

    //   //5.map
    //   Stream<String> stream5 = Stream.of("100", "200", "300");
    //   Stream<Integer> stream = stream5.map((String e) -> {
    //       return Integer.parseInt(e);
    //   });
    //   stream.forEach(e-> System.out.println(e+1));

        //6.concat
        Stream<String> stream6 = Stream.of("谢霆锋", "张柏芝", "王宝强", "马蓉");
        Stream<String> stream7 = Stream.of("100", "200", "300");
        Stream.concat(stream6,stream7).forEach(e-> System.out.println(e));
    }
}
